.TITLE	EXESB
	.IDENT	/15.02/
;
; Copyright (c) 1995 by Mentec, Inc., U.S.A.
; All rights reserved
;
;
; THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED
; OR COPIED ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE.
;
; D. N. CUTLER 4-AUG-73
;
; PREVIOUSLY MODIFIED BY:
;
;	J. R. KAUFFMAN
;	J. M. LAWLER
;	B. S. MCCARTHY
;	K. L. NOEL
;
; MODIFIED BY:
;
;	K. L. NOEL	14-SEP-89	15.00
;
;		KLN147 - MOVE TASK INDEX FIELD
;
;	K. L. NOEL	8-NOV-89	15.01
;
;		KLN152 - CHECK FOR 0 TASK INDEX BEFORE TICLR
;
; Modified for RSX-11M-PLUS V4.6 by:
;
;	D. Carroll	18-Oct-1995	15.02
;		DC404 - Include PSECT definition to allow ICB pool to be
;			fully expanded during sysgen
;
;
;
; I/O RELATED ROUTINES
;
;	ROUTINES CALLED PRIMARILY FROM WITHIN THE EXECUTIVE
;
; MACRO LIBRARY CALLS
;

	.MCALL	F11DF$,HDRDF$,HWDDF$,PCBDF$,PKTDF$,SHDDF$,TCBDF$
	F11DF$			;DEFINE WINDOW AND LOCK BLOCK OFFSETS
	HDRDF$			;DEFINE TASK HEADER OFFSETS
	HWDDF$			;DEFINE HARDWARE REGISTERS
	PCBDF$			;DEFINE PARTITION CONTROL BLOCK OFFSETS
	PKTDF$			;DEFINE I/O PACKET OFFSETS
	SHDDF$			;DEFINE SHADOW RECORDING OFFSETS
	TCBDF$			;DEFINE TASK CONTROL BLOCK OFFSETS
										;DC404
	.IIF	DF,K$$DAS&I$$CBP,	.PSECT	EXEC1				;DC404
										;DC404
	.PAGE
;+
; **-$ACHKP-ADDRESS CHECK PARAMETER BLOCK
; **-$ACHKW-ADDRESS CHECK PARAMETER BLOCK WORD ALIGNED
;
; THESE ROUTINES ARE CALLED TO ADDRESS CHECK A TASK SPECIFIED PARAMETER
; BLOCK TO INSURE IT IS WITHIN THE TASK'S ADDRESS SPACE AND ALIGNED PROPERLY.
; IF EITHER CHECK FAILS, THEN A DIRECTIVE STATUS OF 'D.RS98' IS RETURNED.
;
; INPUTS:
;
;	R0=STARTING ADDRESS OF THE BLOCK TO BE CHECKED.
;	R1=LENGTH OF THE BLOCK TO BE CHECKED IN BYTES.
;
; OUTPUTS:
;
;	THE SPECIFIED BLOCK IS CHECKED FOR PROPER ALIGNMENT AND WHETHER
;	IT IS WITHIN THE TASK'S ADDRESS SPACE. IF EITHER CHECK FAILS,
;	THEN A DIRECTIVE STATUS OF 'D.RS98' IS RETURNED. ELSE A RETURN
;	TO THE CALLER IS EXECUTED.
;
;	R2=ADDRESS OF WINDOW BLOCK MAPPING BUFFER ($ACHKW ONLY)
;		(FOR PRIVILEGED TASKS SEE NOTE IN $ACHKB.)
;
;	R0 AND R3 ARE PRESERVED ACROSS CALL.
;-

	.ENABL	LSB
$ACHKP::MOV	R3,R0		;SET ADDRESS OF BLOCK TO CHECK
	CALL	$ACHCK		;ADDRESS CHECK WORD ALIGNED
	BCS	10$		;IF CS CHECK FAILURE
	CALL	$RELOC		;RELOCATE PARAMETER BLOCK ADDRESS
	MOV	R1,KISAR6	;MAP TO PARAMETER BLOCK
	MOV	R2,R3		;REDEFINE PARAMETER BLOCK ADDRESS
	RETURN			;
$ACHKW::CALL	$ACHCK		;ADDRESS CHECK WORD ALIGNED
	BCC	50$		;IF CC OKAY
10$:	DRSTS	D.RS98		;SET DIRECTIVE STATUS
	.PAGE
;+
; **-$ACHKB-ADDRESS CHECK BYTE ALIGNED
; **-$ACHCK-ADDRESS CHECK WORD ALIGNED
;
; THIS ROUTINE IS CALLED TO ADDRESS CHECK A BLOCK OF MEMORY TO SEE WHETHER
; IT LIES WITHIN THE ADDRESS SPACE OF THE CURRENT TASK.
;
; INPUTS:
;
;	R0=STARTING ADDRESS OF THE BLOCK TO BE CHECKED.
;	R1=LENGTH OF THE BLOCK TO BE CHECKED IN BYTES.
;
; OUTPUTS:
;
;	C=1 IF ADDRESS CHECK FAILED.
;	C=0 IF ADDRESS CHECK SUCCEEDED.
;
;	R2=ADDRESS OF WINDOW BLOCK MAPPING BUFFER
;		(FOR PRIV TASKS SEE NOTE.)
;
;	R0 AND R3 ARE PRESERVED ACROSS CALL.
;
;	NOTE:	SINCE PRIVILEGED TASK I/O BUFFERS ARE NOT ADDRESS
;		CHECKED, R2 ALWAYS RETURNS A POINTER TO THE FIRST
;		WINDOW BLOCK.  CHECKPOINTING AND SHUFFLING OF COMMONS
;		WILL STILL WORK PROPERLY PROVIDED THAT A PRIVILEGED
;		TASK NEVER SPECIFIES AN I/O INTO A COMMON WHICH IT
;		ALLOWS TO REMAIN CHECKPOINTABLE AND SHUFFLEABLE.
;
;		THE ABOVE ALSO IMPLIES THAT ALLOWING A RANDOM
;		REGION TO BE SHUFFLED OR CHECKPOINTED WHILE
;		P.RMCT=0 MIGHT POSSIBLY CHECKPOINT THE REGION
;		WITH THE BUFFER CONTAINED.
;-

$ACHCK::ASR	R0		;ODD ADDRESS?
	BCS	14$		;IF CS YES
	ASL	R0		;REALIGN ADDRESS
$ACHKB::CALL	$ACHRO		;CHECK BUFFER FOR READ ONLY ACCESS
	BCS	14$		;IF CS FAILURE

	.IF DF	X$$HDR

	BIT	#4,$IOTMP	;WRITE ACCESS ALLOWED TO WINDOW ?

	.IFF

	BIT	#4,W.BLPD(R2)	;WRITE ACCESS ALLOWED TO WINDOW ?

	.ENDC	;X$$HDR


	BNE	14$		;IF NE YES
	SEC			;ELSE RETURN CS
14$:	RETURN			;
	.PAGE
;+
; **-$ACHUI-ADDRESS CHECK USER I SPACE (FOR LOAD OVERLAY)
;
; THIS ROUTINE CHECKS THE SPECIFIED USER BUFFER FOR EXISTENCE IN
; USER I SPACE ONLY.
;
; INPUTS:
;
;	R0=STARTING ADDRESS OF THE BLOCK TO BE CHECKED.
;	R1=LENGTH OF THE BLOCK TO BE CHECKED IN BYTES.
;
; OUTPUTS:
;
;	C=1 IF ADDRESS CHECK FAILED.
;	C=0 IF ADDRESS CHECK SUCCEEDED.
;
;	R2=ADDRESS OF WINDOW BLOCK MAPPING BUFFER.
;	   (FOR PRIV TASKS SEE NOTE IN $ACHKB)
;
;	R0 AND R3 ARE PRESERVED ACROSS THE CALL
;-

	.IF DF U$$DAS

$ACHUI::
	.IF DF	X$$HDR

	MOV	KISAR6,-(SP)	;SAVE CURRENT MAPPING
	MOV	$SAHDB,KISAR6	;AND MAP TO CURRENT HEADER

	.ENDC	; DF X$$HDR

	MOV	$SAHPT,R2	;GET ADDRESS OF CURRENT TASK HEADER
	CLR	-(SP)		;FORCE EXAMINATION OF USER I ONLY
	BR	145$		;ENTER COMMON ROUTINE

	.ENDC	; DF U$$DAS
	.PAGE
;+
; **-$ACHRO-ADDRESS CHECK FOR READ-ONLY ACCESS
;
; THIS ROUTINE CHECKS THE SPECIFIED USER BUFFER FOR READ-ONLY ACCESS.
;
; INPUTS:
;
;	R0=STARTING ADDRESS OF THE BLOCK TO BE CHECKED.
;	R1=LENGTH OF THE BLOCK TO BE CHECKED IN BYTES.
;
; OUTPUTS:
;
;	C=1 IF ADDRESS CHECK FAILED.
;	C=0 IF ADDRESS CHECK SUCCEEDED.
;
;	R2=ADDRESS OF WINDOW BLOCK MAPPING BUFFER.
;		(FOR PRIV TASKS SEE NOTE IN $ACHKB.)
;
;	R0 AND R3 ARE PRESERVED ACROSS CALL.
;-

$ACHRO::

	.IF DF	X$$HDR

	MOV	KISAR6,-(SP)	;SAVE CURRENT MAPPING
	MOV	$SAHDB,KISAR6	;AND MAP TO CURRENT TASK HEADER

	.ENDC	; DF X$$HDR

	MOV	$SAHPT,R2	;POINT TO CURRENT TASK HEADER

	.IF DF U$$DAS!S$$LIB

	MOV	H.SMAP(R2),-(SP) ;SAVE USER/SUPER MAPPING MASKS
				 ;FOR LATER
145$:	CLR	-(SP)		;ALLOCATE SPACE FOR BUFFER
				;DESCRIPTOR MASK

	.IFTF	; DF U$$DAS!S$$LIB

	MOV	H.WND(R2),R2	;POINT TO NUMBER OF WINDOW BLOCKS
	MOV	(R2)+,-(SP)	;PUSH NUMBER OF WINDOW BLOCKS
	TST	W.BLVR(R2)	;TASK MAPPED TO EXEC?
	BNE	40$		;IF NE YES, ADDRESS CHECK SUCCEEDS
	DEC	R1		;CALCULATE HIGHEST ADDRESS OF BLOCK
	ADD	R0,R1		;
	BCC	147$		;IF CC ALL IS OK, NO WRAP

;	* * *   SPECIAL NOTE ABOUT PRIVILEGED TASKS   * * *
;
;	IN ORDER TO MAKE THE IMPLEMENTATION OF ADDRESS CHECKING ON
;	RSX-11M-PLUS COMPATIBLE WITH RSX-11M, WHICH SKIPS CHECKS IF
;	T3.PRV IS SET, WE ADDRESS CHECK ONLY THE FIRST ADDRESS, NOT
;	THE LENGTH OF THE TRANSFER. THIS ALLOWS A PR:0 TASK TO PERFORM
;	A LARGE I/O INTO A REGION WHICH IS MAPPED THROUGH A SMALL
;	WINDOW. WE MUST STILL ADDRESS CHECK, SINCE THIS ROUTINE WILL
;	RETURN THE WINDOW BLOCK MAPPING THE BUFFER TO WHICH THE I/O
;	IS TO BE CHARGED.
;
;	SINCE THIS CHECK REQUIRES SEVERAL EXTRA INSTRUCTIONS, IT IS
;	IMPLEMENTED IN THE ERROR PATHS THROUGH THE CHECK ROUTINES.
;

	MOV	$TKTCB,-(SP)	;GET TCB ADDRESS OF CURRENT TASK
	ADD	#T.ST3,(SP)	;POINT TO THIRD TASK STATUS WORD
	BIT	#T3.PRV,@(SP)+	;TASK PRIVILEGED?
	BEQ	30$		;IF EQ NO, ADDRESS WRAP -> FAILURE
147$:				;REFERENCE LABEL

	.IFT	; DF U$$DAS!S$$LIB

	TST	4(SP)		;TASK HAVE ONLY USER I SPACE ?
	BNE	100$		;IF NE NO, GO DO IT THE HARD WAY

	.IFTF	; DF U$$DAS!S$$LIB


15$:	TST	(R2)		;IS NEXT WINDOW MAPPED? (W.BPCB)
	BEQ	20$		;IF EQ NO


	.IF DF	S$$LIB

	TSTB	W.BFPD(R2)	;SUPERVISOR MODE MAPPING?
	BPL	20$		;IF PL YES, IGNORE FOR ADDRESS CHECK

	.ENDC	; DF U$$DAS


	CMP	R0,W.BLVR(R2)	;COMPARE LOW LIMITS
	BLO	20$		;IF LO NOT IN DESCRIPTOR
	CMP	R1,W.BHVR(R2)	;COMPARE HIGH LIMITS
	BLOS	40$		;IF LOS BUFFER IS IN DESCRIPTOR

;	TEST FOR ISSUER PR:0. IF SO MAPPING SUCCESSFUL EVEN THOUGH
;	LAST ADDRESS FAILED MAPPING

	MOV	$TKTCB,-(SP)	;GET TCB ADDRESS OF CURRENT TASK
	ADD	#T.ST3,(SP)	;POINT TO THIRD TASK STATUS WORD
	BIT	#T3.PRV,@(SP)+	;TASK PRIVILEGED?
	BEQ	20$		;IF EQ NO, LAST ADDR. FAILURE
	CMP	R0,W.BHVR(R2)	;LAST ADDRESS FAILURE OK, BUT IS
				;FIRST ADDRESS WITHIN WINDOW?
	BLOS	40$		;IF LOS YES, OK. THIS IS A PRIV TASK
				;WITH A VALID BUFFER THAT OVERLAPS
				;THE END OF THE WINDOW.
20$:	ADD	#W.BLGH,R2	;POINT TO NEXT WINDOW BLOCK
	DEC	(SP)		;MORE DESCRIPTORS TO GO?
	BGT	15$		;IF GT YES
30$:				;REFERENCE LABEL

	.IFT	; DF U$$DAS!S$$LIB

	SUB	#-6,SP		;CLEAR 3 WORDS OFF STACK, SET CARRY

	.IFF	; DF U$$DAS!S$$LIB

	COM	(SP)+		;CLEAN STACK, SET CARRY

	.IFTF	; DF U$$DAS!S$$LIB


	.IF DF	X$$HDR

	MOV	(SP)+,KISAR6	;RESTORE PREVIOUS EXEC MAPPING

	.ENDC	; DF X$$HDR

	RETURN			;
40$:				;REFERENCE LABEL

	.IFT	; DF U$$DAS!S$$LIB

	ADD	#6,SP		;CLEAR 3 WORDS OFF STACK, CLEAR CARRY

	.IFF	;DF U$$DAS!S$$LIB

	TST	(SP)+		;CLEAN STACK, CLEAR CARRY

	.IFTF	; DF U$$DAS!S$$LIB

	.IF DF	X$$HDR


	MOV	W.BLPD(R2),$IOTMP ;SAVE R/W INDICATOR FROM WINDOW

	MOV	(SP)+,KISAR6	;RESTORE PREVIOUS EXEC MAPPING

	.ENDC	; DF X$$HDR
50$:	RETURN			;

; THIS SECTION HANDLES ADDRESS CHECKS FOR TASKS WITH MIXED I/D OR
; USER/SUPER MAPPING. THIS CODE IS DESIGNED TO "FAVOR" (PERFORMANCE)
; TASKS WHOSE I/O IS FULLY MAPPED THROUGH USER D SPACE. THE CODE
; ABOVE FAVORS "SIMPLE" TASKS WITH ONLY USER I SPACE OR USER I
; SUPER I.
;
; FIRST, FIND A WINDOW (IF THERE IS ONE) WHICH CONTAINS THE ENTIRE
; BUFFER

	.IFT	; DF U$$DAS!S$$LIB

100$:	TST	(R2)		;NEXT WINDOW MAPPED ?
	BEQ	110$		;IF EQ NO
	CMP	R0,W.BLVR(R2)	;COMPARE LOW LIMITS
	BLO	110$		;IF LO NOT IN DESCRIPTOR
	CMP	R1,W.BHVR(R2)	;COMPARE HIGH LIMITS
	BLOS	120$		;IF LOS BUFFER IS IN DESCRIPTOR

;	TEST FOR ISSUER PR:0. IF SO MAPPING SUCCESSFUL EVEN THOUGH
;	LAST ADDRESS FAILED MAPPING

	MOV	$TKTCB,-(SP)	;GET TCB ADDRESS OF CURRENT TASK
	ADD	#T.ST3,(SP)	;POINT TO THIRD TASK STATUS WORD
	BIT	#T3.PRV,@(SP)+	;TASK PRIVILEGED?
	BEQ	110$		;IF EQ NO, LAST ADDR. FAILURE
	CMP	R0,W.BHVR(R2)	;LAST ADDRESS FAILURE OK, BUT IS
				;FIRST ADDRESS WITHIN WINDOW?
	BLOS	120$		;IF LOS YES, OK. THIS IS A PRIV TASK
				;WITH A VALID BUFFER THAT OVERLAPS
				;THE END OF THE WINDOW.
110$:	ADD	#W.BLGH,R2	;POINT TO NEXT WINDOW BLOCK
	DEC	(SP)		;MORE DESCRIPTORS TO GO ?
	BGT	100$		;IF GT YES
	BR	30$		;ELSE ADDR. CHECK FAILED

	.ENDC	; DF U$$DAS!S$$LIB

; FOUND A WINDOW WHICH COVERS TRANSFER. CHECK FOR USER D SPACE
; FIRST

120$:				;REFERENCE LABEL

	.IF DF	U$$DAS

	BIT	#20,W.BFPD(R2)	;USER DATA SPACE WINDOW ?
	BEQ	130$		;IF EQ NO

; WINDOW IS USER D SPACE. IF THE REQUEST WAS ISSUED IN USER MODE,
; THEN THE BUFFER IS GUARANTEED TO BE MAPPED.

	.IF DF S$$LIB

	TST	$STACK-2	;ISSUED FROM SUPERVISOR MODE ?
	BMI	40$		;IF MI NO, D SPACE MAP SUCCEEDS

; WINDOW IS D SPACE, BUT REQUEST WAS ISSUED FROM SUPER MODE. THIS IS
; OK ONLY IF THERE IS NO OVERLAP BETWEEN THE BUFFER AND A SUPER
; D APR WHICH HAS BEEN MAPPED INTO SUPER I SPACE.

	CALL	210$		;BUILD SUPER BUFFER APR MASK
	BITB	2(SP),4(SP)	;ANY PART OVERLAP SUPER I/D WINDOW ?
	BEQ	40$		;IF EQ NO, SUCCESS
	BR	110$		;KEEP TRYING

	.ENDC	; DF S$$LIB

	.ENDC	; DF U$$DAS

; WINDOW IS EITHER USER I OR SUPER I. CHECK FOR USER I

130$:				;REFERENCE LABEL

	.IF DF S$$LIB

	TSTB	W.BFPD(R2)	;USER I OR SUPER I WINDOW ?
	BPL	150$		;IF PL SUPER I

	.ENDC	; DF S$$LIB

; WINDOW IS  USER I SPACE. LOOK FOR CONFLICT WITH DISCRETE D SPACE
; WINDOW. FOR PERFORMANCE, WE BUILD THE MASK IF WE NEED IT, BUT ONLY
; ONCE IN ANY CASE.

	.IF DF	U$$DAS

	CALL	210$		;ESTABLISH MAPPING MASK

140$:	BITB	3(SP),5(SP)	;ANY OF BUFFER OVERLAP DISCRETE WINDOW ?
	BNE	110$		;IF NE YES, KEEP GOING

	.ENDC	; DF U$$DAS

	BR	40$		;SUCCESSFUL

; WINDOW IS SUPER I. IF ISSUED IN USER MODE IGNORE WINDOW, ELSE MAKE SURE
; ENTIRE WINDOW IS OVERMAPPED.

	.IF DF	S$$LIB

150$:	TST	$STACK-2	;ISSUED IN SUPER MODE ?
	BMI	110$		;IF MI NO, IGNORE WINDOW

; SINCE SUPER WINDOWS CAN'T MAP APR0 INTO SUPER I SPACE, IGNORE WINDOW
; IF TRANSFER STARTS IN APR0

	CMP	#20000,R0	;BUFFER START IN APR 0 ?
	BHI	110$		;IF HI YES, CAN'T BE THROUGH SUPER

; ESTABLISH SUPERVISOR MASK AND MAKE SURE WHOLE TRANSFER FITS THROUGH
; SUPER I WINDOW

	CALL	210$		;ESTABLISH SUPER D OVERMAP MASK
	MOVB	2(SP),-(SP)	;COPY SUPER BUFFER APR MASK
	BICB	6(SP),(SP)+	;FULL BUFFER IN SUPER WINDOW ?
	BEQ	40$		;IF EQ YES
	BR	110$		;ELSE NO

	.ENDC	; DF S$$LIB

; LOCAL SUBROUTINE TO ESTABLISH SUPER BUFFER MAPPING MASK

	.IF DF	U$$DAS!S$$LIB

210$:	TSTB	5(SP)		;USER D MAP BUILT YET ?
	BNE	220$		;IF NE YES
	MOV	R2,-(SP)	;SAVE POINTER TO CURRENT WINDOW BLOCK
	MOV	R1,R2		;COPY END ADDRESS OF BUFFER
	ASH	#-13.,R2	;REDUCE TO JUST APR
	BIC	#177770,R2	;CLEAR UNWANTED BITS
	MOVB	$BCMSK(R2),7(SP) ;INIT MASK TO ALL UP TO UPPER ADDRESS
	MOV	R0,R2		;COPY START ADDRESS OF BUFFER
	ASH	#-13.,R2	;REDUCE TO JUST APR
	BIC	#177770,R2	;CLEAR UNWANTED BITS
	BICB	$BCMSK-1(R2),7(SP) ;INIT MASK TO ALL UP TO UPPER ADDRESS
	MOVB	7(SP),6(SP)	;INIT SUPER MASK
	CLC			;GET SET FOR SHIFT
	RORB	6(SP)		;SUPER MASK IS ORIGIN ONE
	MOV	(SP)+,R2	;RESTORE WINDOW POINTER
220$:	RETURN			;

	.ENDC	;DF U$$DAS!S$$LIB

	.DSABL	LSB
	.PAGE
;+
; **-$CKBFI-CHECK I/O BUFFER FOR I-SPACE (OVERLAY) ACCESS
; **-$CKBFR-CHECK I/O BUFFER FOR READ-ONLY (BYTE) ACCESS
; **-$CKBFW-CHECK I/O BUFFER FOR READ-WRITE (WORD) ACCESS
; **-$CKBFB-CHECK I/O BUFFER FOR READ-WRITE (BYTE) ACCESS
;
; THESE ROUTINES ARE CALLED TO ADDRESS CHECK AN I/O BUFFER
; ASSOCIATED WITH THE CURRENT (UNDER CONSTRUCTION) I/O PACKET.
; IF THE ADDRESS CHECK PASSES, THEN AN ATTEMPT IS MADE TO POINT ONE
; OF THE ATTACHMENT DESCRIPTOR POINTERS AT THE ASSOCIATED ADB. THIS
; WILL HAVE ONE OF THE FOLLOWING OUTCOMES:
;
; 1) - THERE IS CURRENTLY NO ATTACHMENT POINTER IN THE PACKET TO THIS
;      ADB, AND THE POINTERS AREN'T FULL. A POINTER IS FILLED IN AND
;      THE A.IOC, P.IOC FIELDS FOR THIS I/O ARE INCREMENTED. THIS IS
;      THE "NORMAL" SUCCESSFUL CASE.
;
; 2) - THERE IS ALREADY ONE POINTER TO THIS ADB. THE PACKET IS
;      UNTOUCHED, AS ARE THE A.IOC AND P.IOC FIELDS, AND THE CHECK
;      IS CONSIDERED SUCCESSFUL. THE IMPLICATION OF NOT INCREMENTING
;      A.IOC AND P.IOC IS THAT DRIVERS AND ACPS MAY NOT RELEASE
;      BUFFERS FOR AN I/O REQUEST ONE AT A TIME, I.E. THE DRIVER
;      SHOULD NOT CALL $DECIO DIRECTLY, BUT SHOULD CALL $IODON OR
;      $DECAL AFTER ALL BUFFER ACCESS HAS SCOMPLETED.
;
; 3) - THERE ARE ALREADY TWO POINTERS, NONE OF THEM TO THIS ATTACHMENT
;      DESCRIPTOR. THIS IS CONSIDERED A CHECK FAILURE AND RETURN
;      IS MADE WITH CARRY SET.
;
; INPUTS:
;
;	R0=STARTING ADDRESS OF BLOCK TO BE CHECKED
;	R1=LENGTH OF BUFFER TO BE CHECKED
;	$ATTPT=ADDRESS OF I.AADA IN CURRENT I/O PACKET
;	HEADER OF THE SUBJECT TASK IS MAPPED THROUGH KISAR6
;
; OUTPUTS:
;
;	C=0 CHECK AND PACKET UPDAT SUCCESSFUL
;		I.AADA OR I.AADA+2 POINTS TO THE ADB
;		A.IOC, P.IOC INCREMENTED
;	C=1 CHECK UNSUCCESSFUL OR PACKET COULD NOT BE FILLED IN
;-

	.ENABL	LSB

	.IF DF	U$$DAS

$CKBFI::CALL	$ACHUI		;PERFORM ADDRESS CHECK
	BR	10$		;ENTER COMMON CODE

	.ENDC	; DF U$$DAS

$CKBFR::CALL	$ACHRO		;PERFORM ADDRESS CHECK
	BR	10$		;ENTER COMMON CODE

$CKBFW::CALL	$ACHCK		;PERFORM ADDRESS CHECK
	BR	10$		;ENTER COMMON CODE

$CKBFB::CALL	$ACHKB		;PERFORM ADDRESS CHECK

10$:	BCS	50$		;IF CS ADDRESS CHECK UNSUCCESSFUL
	MOV	R0,-(SP)	;SAVE ADDRESS OF BUFFER
	MOV	W.BATT(R2),R1	;GET ADDRESS OF ATTACHMENT DESCRIPTOR
	MOV	$ATTPT,R0	;POINT TO ADDRESS OF FIRST ADB
	TST	(R0)		;FIRST ADB POINTER FULL ?
	BNE	40$		;IF NE YES, CHECK FOR MATCH OR SECOND
20$:	MOV	R1,(R0)		;FILL IN POINTER
	INCB	A.IOC(R1)	;INCREMENT I/O THROUGH ATTACHMENT COUNT
	MOV	A.PCB(R1),R0	;POINT TO ASSOCIATED PCB
	INCB	P.IOC(R0)	;INCREMENT I/O INTO PARTION COUNT
30$:	MOV	(SP)+,R0	;RESTORE BUFFER ADDRESS
	CLC			;INDICATE SUCCESS
	RETURN			;
40$:	CMP	R1,(R0)+	;ALREADY POINTING TO DESIRED ADB ?
	BEQ	30$		;IF EQ YES, DONE, RETURN SUCCESS
	TST	(R0)		;SECOND POINTER FULL ?
	BEQ	20$		;IF EQ NO, USE IT
	CMP	R1,(R0)		;SECOND POINTER SAME AS DESIRED ?
	BEQ	30$		;IF EQ YES, DONE, RETURN SUCCESS
	SEC			;INDICATE FAILURE
	MOV	(SP)+,R0	;RESTORE BUFFER ADDRESS
50$:	RETURN			;

	.DSABL	LSB
	.PAGE
;+
; **-$CEFNG-CONVERT EVENT FLAG AND LOCK GROUP GLOBALS FOR DIRECTIVE
; **-$CEFIG-CONVERT EVENT FLAG AND LOCK GROUP GLOBALS FOR I/O
;
; THIS ROUTINE IS CALLED TO CONVERT AN EVENT FLAG NUMBER TO AN
; EVENT FLAG MASK WORD AND EVENT FLAG MASK ADDRESS. IF THE EVENT
; FLAG IS GROUP GLOBAL, POINT THE GROUP GLOBAL USE COUNT POINTER IN
; SYSTEM COMMON TO THE FLAG WORD RETURNED IN R1. IF R1 IS ODD, R1
; IS POINTING TO THE SECOND GROUP OF GROUP GLOBAL EVENT FLAGS.
;
; INPUTS:
;
;	R0=EVENT FLAG TO BE CONVERTED.
;	R3=ADDRESS CONTAINING EVENT FLAG NUMBER ($CEFNG ONLY)
;	R5=TCB ADDRESS OF THE TASK THE EFN APPLIES TO.
;
; OUTPUTS:
;
;	C=1 IF NO EVENT FLAG NUMBER WAS SPECIFIED.
;		R0=ZERO.
;		R1=ZERO.
;	C=0 IF AN EVENT FLAG NUMBER WAS SPECIFIED.
;		R0=EVENT FLAG MASK WORD.
;		R1=EVENT FLAG MASK ADDRESS.
;			R1 IS EVEN IF THE EVENT FLAG NUMBER < 81.
;			R1 IS ODD IF THE EVENT FLAG NUMBER > 81.
;
;	R3 IS PRESERVED ACROSS CALL IF ENTRY AT $CEFIG, ELSE R3 IS
;	   ADVANCED BY 2.
;
;-

	.ENABL	LSB

$CEFIG::CALL	$CEFI		;CONVERT THE EVENT FLAG
	BR	5$		;JOIN COMMON CODE
$CEFNG::CALL	$CEFN		;CONVERT THE EVENT FLAG
5$:				;REFERENCE LABEL

	.IF DF	G$$GEF

	BCS	30$		;IF CS RETURN
	BNE	30$		;IF NE RETURN
	MOV	R1,-(SP)	;SAVE GROUP GLOBAL MASK ADDRESS
	TSTB	-(R1)		;POINT TO GROUP GLOBAL USE COUNT
	TSTB	-(R1)		;R1 MAY BE ODD - CLEAR C-BIT
	ASSUME	G.CNT+2,G.EFLG	;MUST BE CONTIGUOUS
	BIT	#1,R1		;USING SECOND MASK WORD?
	BEQ	10$		;IF EQ NO, WE ARE POINTING TO USE COUNT
	SUB	#3,R1		;POINT TO GROUP GLOBAL USE COUNT
10$:	MOV	R1,@#$GEFPT	;LOAD GROUP GLOBAL USE COUNT POINTER
	MOV	(SP)+,R1	;RESTORE EVENT FLAG MASK ADDRESS
	MOV	R5,$GFTCB	;DISPATCHER WILL MAINTAIN THE CORRECT
	ADD	#T.GGF,$GFTCB	; GRP GBL USE COUNT PER TASK W/THIS PNTR

	.ENDC	; DF G$$GEF

30$:	RETURN

	.DSABL	LSB
;+
; **-$CEFN-CONVERT EVENT FLAG NUMBER FOR DIRECTIVE
; **-$CEFI-CONVERT EVENT FLAG NUMBER FOR I/O
;
; THIS ROUTINE IS CALLED TO CONVERT AN EVENT FLAG NUMBER TO AN
; EVENT FLAG MASK WORD AND EVENT FLAG MASK ADDRESS. IF AN ILLEGAL
; EVENT FLAG IS SPECIFIED, THEN A DIRECTIVE STATUS OF 'D.RS97' IS
; RETURNED. ELSE THE EVENT FLAG NUMBER IS CONVERTED AND THE COM-
; PONENT PARTS ARE RETURNED TO THE CALLER.
;
; INPUTS:
;
;	R0=EVENT FLAG NUMBER TO BE CONVERTED.
;	R3=ADDRESS CONTAINING EVENT FLAG NUMBER ($CEFN ONLY)
;	R5=TCB ADDRESS OF THE TASK THE EFN APPLIES TO.
;
; OUTPUTS:
;
;	C=1 IF NO EVENT FLAG NUMBER WAS SPECIFIED.
;		R0=ZERO.
;		R1=ZERO.
;	C=0 IF AN EVENT FLAG NUMBER WAS SPECIFIED.
;		R0=EVENT FLAG MASK WORD.
;		R1=EVENT FLAG MASK ADDRESS.
;			R1 IS EVEN IF THE EVENT FLAG < 81.
;			R1 IS ODD IF THE EVENT FLAG > 81.
;	Z=1 IF GROUP GLOBAL EVENT FLAG CONVERTED
;	Z=0 IF LOCAL OR COMMON EVENT FLAG CONVERTED
;
;	R3 IS PRESERVED ACROSS CALL IF ENTRY AT $CEFI, ELSE R3 IS ADVANCED BY 2.
;-

$CEFN:: MOVB	(R3)+,R0	;GET EVENT FLAG NUMBER
	INC	R3		;ADVANCE TO NEXT WORD
$CEFI::				;REFERENCE LABEL

	.IF DF G$$GEF

	CLR	-(SP)		;INIT GROUP GLOBAL INDICATOR

	.IFTF	; DF G$$GEF

	MOV	R0,R1		;COPY EFN
	SEC			;ASSUME NONE SPECIFIED
	BEQ	30$		;IF EQ NO EFN SPECIFIED
	DEC	R0		;BACK OFF EFN BY ONE
	MOV	#32.,R2		;SET EFN DIVIDER
	MOV	R5,R1		;POINT TO FIRST TASK MASK WORD
	ADD	#T.EFLG,R1	;
	CMP	R0,R2		;IN TASK EFN SET?
	BLO	10$		;IF LO YES
	SUB	R2,R0		;NORMALIZE TO COMMON SET
	CMP	R0,R2		;LEGAL EFN?

	.IFT	; DF G$$GEF

	BLO	5$		;IF LO YES
	SUB	R2,R0		;NORMALIZE TO GROUP GLOBAL SET
	CMP	R0,R2		;LEGAL EFN?
	BHIS	40$		;IF HIS NO
	CALL	$GTGEF		;GET ADDRESS OF GROUP GLOBAL EVENT FLAGS
	BCS	40$		;IF CS NO SUCH FLAG OR TASK CHECKPOINTED
	DEC	(SP)		;FLAG THAT FLAG WAS FOUND
	BR	10$		;USE GROUP GLOBAL SET

	.IFF	; DF G$$GEF

	BHIS	40$		;IF HIS NO

	.IFTF	; DF G$$GEF

5$:	MOV	#$COMEF,R1	;POINT TO FIRST COMMON MASK WORD
10$:	ASR	R2		;HALVE DIVIDER
	CMP	R0,R2		;FIRST MASK WORD?
	BLO	20$		;IF LO YES
	SUB	R2,R0		;NORMALIZE EFN
	TST	(R1)+		;POINT TO SECOND MASK WORD

	.IFT	; DF G$$GEF

	TST	(SP)		;GROUP GLOBAL FLAG FOUND?
	BEQ	20$		;IF EQ NO
	INC	R1		;MARK AS SECOND GROUP GLOBAL WORD

	.IFTF	; DF G$$GEF

20$:	ASL	R0		;CONVERT EFN TO WORD INDEX
	MOV	$BTMSK(R0),R0	;GET PROPER MASK WORD
30$:				;REFERENCE LABEL

	.IFT	; DF G$$GEF

	INC	(SP)+		;CLEAN STACK, PRESRV C-BIT, SET Z BIT

	.ENDC	; DF G$$GEF

	RETURN
40$:	DRSTS	D.RS97		;SET DIRECTIVE STATUS
	.PAGE
;+
; **-GTGEF-GET ADDRESS OF GROUP GLOBAL EVENT FLAGS
;
; THIS ROUTINE SEARCHES FOR GROUP GLOBAL EVENT FLAGS FOR A SPECIFIED
; TASK. IF THE EVENT FLAG EXISTS, THE ADDRESS OF THE EVENT FLAG
; WORD IS RETURNED IN R1.
;
; INPUTS:
;
;	R5=TCB ADDRESS OF TASK.
;
; OUTPUTS:
;
;	C=0 IF GROUP GLOBAL EVENT FLAGS WERE FOUND
;		R1=ADDRESS OF GROUP GLOBAL EVENT FLAGS
;
;	C=1 IF THE EVENT FLAGS WERE NOT FOUND OR IF THE SPECIFIED
;	    TASK IS CHECKPOINTED.
;
;-


	.IF DF	G$$GEF

$GTGEF::MOV	R0,-(SP)	;SAVE REGISTERS
	MOV	R4,-(SP)	;
	MOV	T.PCB(R5),R4	;GET TASK REGION PCB ADDRESS
	BIT	#PS.OUT!PS.CKP,P.STAT(R4) ;TASK HEADER ACCESSIBLE ?
	SEC			;ASSUME IT WAS
	BNE	10$		;IF NE YES

	.IF DF	X$$HDR

	MOV	KISAR6,-(SP)	;SAVE MAPPING IN CASE XTRNL HDR
	MOV	P.HDR(R4),-(SP)	;GET HEADER ADDRESS
	BNE	5$		;IF NE RESIDENT HEADER
	MOV	P.REL(R4),KISAR6 ;MAP TO EXTERNAL HEADER
	MOV	#140000,(SP)	;SET HEADER VIRTUAL ADDRESS
5$:	MOV	(SP)+,R4	;RETRIEVE HEADER ADDRESS
	MOVB	H.CUIC+1(R4),R4	;GET GROUP NUMBER
	MOV	(SP)+,KISAR6	;RESTORE PREVIOUS MAPPING

	.IFF	; DF X$$HDR

	MOV	P.HDR(R4),R4	;GET TASK HEADER ADDRESS
	MOVB	H.CUIC+1(R4),R4	;GET GROUP NUMBER

	.ENDC	; DF X$$HDR

	CALL	$SRGEF		;SEARCH FOR GROUP GLOBAL EVENT FLAGS
	BCS	10$		;IF CS NOT FOUND
	ADD	#6,R1		;POINT TO FIRST EVENT FLAG WORD
10$:	MOV	(SP)+,R4	;RESTORE REGISTERS
	MOV	(SP)+,R0	;
	RETURN

	.PAGE
;+
; **-$SRGEF-SEARCH FOR GROUP GLOBAL EVENT FLAGS
;
; THIS ROUTINE IS CALLED TO SEARCH FOR GROUP GLOBAL EVENT FLAGS
;
; INPUTS:
;
;	R4=GROUP NUMBER
;
; OUTPUTS:
;
;	C=1 IF SPECIFIED GROUP GLOBAL EVENT FLAGS NOT FOUND
;	C=0 IF SPECIFIED GROUP GLOBAL EVENT FLAGS ARE FOUND
;		R0=ADDRESS OF WORD POINTING TO BLOCK
;		R1=ADDRESS OF THE BLOCK
;
;-

$SRGEF::MOV	#$GGEF,R1	;GET ADDRESS OF GROUP GLOBAL EF HEAD
10$:	MOV	R1,R0		;SAVE POINTER TO CURRENT BLOCK
	MOV	(R1),R1		;GET ADDRESS OF NEXT BLOCK
	BEQ	20$		;IF EQ END OF LIST
	CMPB	G.GRP(R1),R4	;IS THIS THE CORRECT BLOCK?
	BEQ	30$		;IF EQ YES
	BLO	10$		;IF LO KEEP SEARCHING
20$:	SEC			;SET CARRY TO INDICATE NOT FOUND
30$:	RETURN			;


	.ENDC	; DF G$$GEF

	.PAGE
;+
; **-$CVDVN-CONVERT DEVICE NAME AND LOGICAL UNIT TO UCB ADDRESS
;
; THIS ROUTINE TAKES A 2 CHARACTER ASCII NAME AND A
; UNIT NUMBER AND SEARCHES THE DEVICE TABLES TO FIND
; THE CORRESPONDING UCB ADDRESS.
;
; INPUTS:
;
;	R0=TWO CHARACTER ASCII DEVICE NAME.
;	R1=UNIT NUMBER.
;
; OUTPUTS:
;
;	C=0 IF DEVICE WAS FOUND.
;		R2=UCB ADDRESS.
;		R3=DCB ADDRESS.
;	C=1 IF DEVICE NOT FOUND.
;
;-

$CVDVN::SAVNR			;SAVE REGISTERS
	MOV	#$SCDVT,-(SP)	;SET UP TO SCAN DEVICE TABLES
10$:	CALL	@(SP)+		;GET ADDRESS OF NEXT DCB
	BCS	100$		;IF CS END OF LIST
	CLR	S$$SPC(SP)	;SET UP TO SKIP THIS DCB IF NO MATCH
	CMP	D.NAM(R3),R0	;DEVICE NAMES MATCH?
	BNE	10$		;IF NE NO
	CMPB	D.UNIT+1(R3),R1	;UNIT ASSOCIATED WITH THIS DCB?
	BLO	10$		;IF LO NO
	CMPB	D.UNIT(R3),R1	;MAYBE
	BHI	10$		;IF HI NO
	ADD	#S$$SPA,SP	;ABORT DEVICE SCAN
	MOV	R5,R2		;COPY ADDRESS OF FIRST UCB
	MOV	R1,R5		;COPY UNIT NUMBER
	SUB	D.UNIT(R3),R5	;CALCULATE NUMBER OF UCBS TO SKIP
	CLC			;INDICATE SUCCESS
20$:	DECB	R5		;IS THIS THE CORRECT UCB?
	BLT	100$		;IF LT YES
	ADD	D.UCBL(R3),R2	;POINT TO NEXT UCB
	BR	20$		;CONTINUE SCAN
100$:	RETURN			;
	.PAGE
;+
; **-$TICLR-CLEAR TI: ASSIGNMENT
;
; THIS ROUTINE IS CALLED TO CLEAR THE TI: ASSIGNMENT OF THE CURRENT
; TASK IN CASE THE CURRENT TASK'S TI: IS A VIRTUAL TERMINAL.
;
; INPUTS:
;
;	NONE.
;
; OUTPUTS:
;
;	R0-R3 ARE MODIFIED.
;-


	.IF DF	V$$TRM!C$$RTK

$TICLR::MOV	$TKTCB,R3	;PICK UP CURRENT TASK TCB ADDRESS

	.IF DF	C$$RTK		;REMOTE TASK SUPPORT

	TSTB	T.TKI(R3)	;HAS THIS TASK EVER SENT A PACKET?
	BEQ	130$		;IF EQ NO, NO NEED TO DO SPECIAL STUFF
	BIT	#F5.RTK,$FMSK5	;REMOTE TASK SUPPORT TURNED ON?
	BEQ	130$		;IF EQ NO

	CMPB	T.TKI(R3),$RMTSK ;IS IT ONE OF THE STATIC REMOTE TASKS - OR -
				; IF ZERO, IT HAS NEVER ASSIGNED A LUN
	BLOS	130$		;IF LOS, YES

	CMPB	T.TKI(R3),#-1	;HAS THIS TASK BEEN TERMINATED ALREADY?
	BEQ	130$		;IF EQ YES, NO NEED TO CLEAR LUNS OR TERMINATE
				; TASK AGAIN
	MOV	R5,-(SP)	;SAVE REG
	MOV	KISAR6,-(SP)	;SAVE MAPPING
	MOV	$SAHDB,KISAR6	;MAP HEADER OF CURRENT TASK
	MOV	R3,R5		;COPY TCB ADDRESS
	MOV	$SAHPT,R1	;POINT TO TASK HEADER
	ADD	#H.NLUN,R1	;POINT TO NUMBER OF LUNS
	MOV	(R1)+,R3	;GET NUMBER OF LUNS
	BEQ	125$		;IF NONE, DON'T NEED TO CLEAR LUNS
90$:
	MOV	(R1),R0		;GET UCB ADDRESS
	BEQ	110$		;IF EQ, NOT ASSIGNED
	CALL	$MPLND		;FOLLOW ALL REDIRECTS
	CMP	(R0),$XXLOW	;IS IT A GENERIC DEVICE
	BLO	110$		;IF LO NO
	CMP	(R0),$XXHGH	;IS IT A GENERIC DEVICE
	BHI	110$		;IF HI NO
100$:
	CLR	(R1)+		;CLEAR TABLE ENTRY
	CLR	(R1)+		;
	BR	120$		;
110$:
	CMP	(R1)+,(R1)+	;DON'T CLEAR THIS ENTRY
120$:	SOB	R3,90$		;LOOP FOR ALL LUNS
125$:
	MOV	(SP)+,KISAR6	;RESTORE MAPPING
	MOV	#AL$SWS,R0	;INDICATE WE WANT TO COME BACK WITH CS IF ERROR
	MOV	#1,R1		;NEED JUST ONE BLOCK
	CALL	$CPALO		;ALLOCATE A BLOCK OF CPRBUF
	BCS	127$		;IF CS, JUST DON'T DO THE TASK TERMINATION

	MOV	KISAR6,-(SP)	;SAVE MAPPING
	MOV	R0,KISAR6	;MAP PACKET
	MOV	#140000,R1	;POINT TO HEADER OF PACKET
	MOVB	#HT$TKN,H$TYPE(R1) ;TASK TERMINATION PACKET
	CLRB	H$ICNT(R1)	;INDICATE NO ITEMS
	MOV	(SP)+,KISAR6	;RESTORE MAPPING

	CPSEN$	#SN$DET,R0,#H$SIZE	;SEND TASK TERMINATION PACKET
127$:
	CLRB	T.TKI(R5)	;CLEAR TASK INDEX SO TASK DOESN'T TRY ANYTHING
				; WITHOUT A TASK START
	MOV	R5,R3		;RESTORE TCB ADDRESS
	MOV	(SP)+,R5	;RESTORE REG

	.ENDC	;C$$RTK

	.IF DF V$$TRM
130$:
	MOV	T.UCB(R3),R0	;PICK UP TI: UCB ADDRESS
	MOV	(R0),R1		;POINT TO TI: DCB ADDRESS
	CMP	D.NAM(R1),#"VT	;IS IT A VIRTUAL TERMINAL?
	BNE	150$		;IF NE NO

	.IF DF	D$$PAR

	MOV	KINAR5,-(SP)	;SAVE APR 5
	MOV	$DRAPR,KINAR5	;MAP TO THE DIRECTIVE PARTITION

	.ENDC

	CALL	$CVTLN		;CLEAR OUT ANY LUNS ASSIGNED TO VT:
	DECB	U.OCNT(R0)	;REDUCE VT: OFFSPRING COUNT
	BNE	140$		;IF NE THERE ARE OTHER ACTIVE OFFSPRING
	TST	U.PTCB(R0)	;IS VT: UNIT MARKED FOR DEALLOCATION?
	BNE	140$		;IF NE NO
	MOV	R3,-(SP)	;SAVE TCB ADDRESS
	CALL	$DEAVT		;DEALLOCATE THE VT: UNIT
	MOV	(SP)+,R3	;RESTORE TCB ADDRESS
140$:				;REFERENCE SYMBOL

	.IF DF	D$$PAR

	MOV	(SP)+,KINAR5	;RESTORE MAPPING

	.ENDC


	MOV	$COPT,R0	;POINT TO CO: UCB
	CALL	$MPLND		;FOLLOW REDIRECTION
	MOV	R0,T.UCB(R3)	;ASSIGN TI: TO CO:

	.ENDC	;V$$TRM

150$:	RETURN			;

	.IFF

$TICLR::RETURN			;NOP ROUTINE IF LACK OF SUPPORT

	.ENDC

	.PAGE
;+
; **-$MPLNE-MAP LOGICAL UNIT NUMBER FOR EXIT
; **-$MPLUN-MAP LOGICAL UNIT NUMBER
;
; THIS ROUTINE IS CALLED TO VALIDATE A LOGICAL UNIT NUMBER (LUN) AND TO MAP
; THE LUN INTO A UCB POINTER. IF AN ILLEGAL LUN IS SPECIFIED, THEN A
; DIRECTIVE STATUS OF 'D.RS96' IS RETURNED. ELSE THE LUN IS MAPPED AND A
; POINTER TO THE LUN AND UCB ARE RETURNED TO THE CALLER.
;
; INPUTS:
;
;	R3=ADDRESS OF THE LUN.
;	R4=ADDRESS OF THE HEADER OF THE CURRENT TASK.
;	R5=ADDRESS OF THE TCB OF THE CURRENT TASK.
;
; OUTPUTS:
;
;	C=1 IF NO DEVICE IS ASSIGNED TO THE SPECIFIED LUN.
;		R0=0.
;	C=0 IF A DEVICE IS ASSIGNED TO THE SPECIFIED LUN.
;		R0=ADDRESS OF REDIRECTED-TO UCB
;		R2=ADDRESS OF REDIRECTED-TO UCB OR SPOOLED DEVICE
;
;	IN EITHER CASE R1 IS RETURNED AS THE ADDRESS OF THE SECOND LUN
;	WORD IN THE TASK HEADER AND R3 IS ADVANCED BY 2.
;-

	.ENABL	LSB
$MPLUN::CLR	R1		;GET LOGICAL UNIT NUMBER
	BISB	(R3)+,R1	;
	INC	R3		;POINT TO NEXT WORD
	DEC	R1		;BACK OFF LUN BY 1
	CMP	R1,H.NLUN(R4)	;LEGAL LUN?
	BHIS	40$		;IF HIS NO
$MPLNE::ASL	R1		;MULTIPLY LUN-1 BY 4
	ASL	R1		;
	ADD	R4,R1		;CALCULATE ADDRESS OF FIRST LUN WORD
	ADD	#H.NLUN+2,R1	;IN TASK HEADER
	SEC			;ASSUME LUN NOT ASSIGNED
	MOV	(R1)+,R0	;GET POINTER TO DEVICE UCB
	BEQ	30$		;IF EQ NO DEVICE ASSIGNED
$MPLND::MOV	R0,R2		;INITIALIZE SPOOLED DEVICE UCB PTR
5$:	CMP	R0,U.RED(R0)	;IS DEVICE REDIRECTED?
	BEQ	10$		;IF EQ NO
	MOV	U.RED(R0),R0	;GET POINTER TO REDIRECT UCB
	BIT	#DV.ISP!DV.OSP,U.CW1(R2) ;SPOOLED DEVICE YET?
	BEQ	$MPLND		;IF EQ NO, ADVANCE R2 AS WELL
	BR	5$		;ELSE INHIBIT ADVANCEMENT OF R2
10$:	MOV	(R0),-(SP)	;GET ADDRESS OF DEVICE DCB
	ADD	#D.NAM,(SP)	;POINT TO DEVICE NAME IN DCB
	CMP	#"TI,@(SP)+	;TERMINAL INPUT PSEUDO DEVICE?
	BNE	20$		;IF NE NO
	MOV	T.UCB(R5),R0	;GET ADDRESS OF "TI" UCB
	BR	$MPLND		;
20$:	CLC			;INDICATE DEVICE ASSIGNED
30$:	RETURN			;
40$:	DRSTS	D.RS96		;SET DIRECTIVE STATUS

	.DSABL	LSB

	.PAGE
;+
; **-$TKWSE-TASK WAITFOR SIGNIFICANT EVENT
;
; THIS ROUTINE IS CALLED TO EXECUTE A WAITFOR SIGNIFICANT EVENT DIRECTIVE FOR
; THE CURRENT TASK FROM WITHIN THE EXECUTIVE.
;
; INPUTS:
;
;	NONE.
;
; OUTPUTS:
;
;	A WAITFOR SIGNIFICANT EVENT DIRECTIVE IS EXECUTED FOR THE CURRENT
;	TASK AND A RETURN TO THE CALLER IS EXECUTED.
;-

$TKWSE::MOV	$TKTCB,R5	;GET ADDRESS OF CURRENT TASK TCB

;+
; **-$DRWSE-WAITFOR SIGNIFICANT EVENT
;
; THIS DIRECTIVE INSTRUCTS THE SYSTEM TO SUSPEND THE EXECUTION OF THE
; ISSUING TASK UNTIL THE NEXT SIGNIFICANT EVENT.
;
; DPB FORMAT:
;
;	WD. 00 -- DIC(49.),DPB SIZE(1.).
;
; INPUTS:
;
;	R2=ADDRESS OF THE TASK STATUS WORD OF THE CURRENT TASK.
;	R3=ADDRESS OF THE LAST WORD IN THE DPB+2.
;	R4=ADDRESS OF THE HEADER OF THE CURRENT TASK.
;	R5=ADDRESS OF THE TCB OF THE CURRENT TASK.
;
; OUTPUTS: (DIRECTIVE STATUS AND PS RETURNED TO TASK)
;
;	C=0 WITH A DIRECTIVE STATUS OF +1.
;-

$DRWSE::MOV	T.ACTL(R5),R0	;GET TCB ADDRESS OF NEXT TASK
	MOV	R5,$SIGFL	;SET TASK WAITING FOR SIGNIFICANT EVENT
	CALLR	$SETRQ		;FORCE REDISPATCHING OF THE PROCESSOR

	.END